home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 60 / IOPROG_60.ISO / soft / c++ / gsl-1.1.1-setup.exe / {app} / src / randist / test.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-22  |  29.4 KB  |  1,517 lines
  1. /* randist/test.c
  2.  * 
  3.  * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough
  4.  * 
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or (at
  8.  * your option) any later version.
  9.  * 
  10.  * This program is distributed in the hope that it will be useful, but
  11.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * General Public License for more details.
  14.  * 
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. #include <config.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <math.h>
  24. #include <gsl/gsl_math.h>
  25. #include <gsl/gsl_randist.h>
  26. #include <gsl/gsl_rng.h>
  27. #include <gsl/gsl_test.h>
  28. #include <gsl/gsl_ieee_utils.h>
  29.  
  30. #define N 100000
  31. void testMoments (double (*f) (void), const char *name,
  32.            double a, double b, double p);
  33. void testPDF (double (*f) (void), double (*pdf)(double), const char *name);
  34. void testDiscretePDF (double (*f) (void), double (*pdf)(unsigned int), 
  35.             const char *name);
  36.  
  37. void test_shuffle (void);
  38. void test_choose (void);
  39. double test_beta (void);
  40. double test_beta_pdf (double x);
  41. double test_bernoulli (void);
  42. double test_bernoulli_pdf (unsigned int n);
  43. double test_binomial (void);
  44. double test_binomial_pdf (unsigned int n);
  45. double test_binomial_large (void);
  46. double test_binomial_large_pdf (unsigned int n);
  47. double test_cauchy (void);
  48. double test_cauchy_pdf (double x);
  49. double test_chisq (void);
  50. double test_chisq_pdf (double x);
  51. double test_discrete1 (void);
  52. double test_discrete1_pdf (unsigned int n);
  53. double test_discrete2 (void);
  54. double test_discrete2_pdf (unsigned int n);
  55. double test_erlang (void);
  56. double test_erlang_pdf (double x);
  57. double test_exponential (void);
  58. double test_exponential_pdf (double x);
  59. double test_exppow0 (void);
  60. double test_exppow0_pdf (double x);
  61. double test_exppow1 (void);
  62. double test_exppow1_pdf (double x);
  63. double test_exppow1a (void);
  64. double test_exppow1a_pdf (double x);
  65. double test_exppow2 (void);
  66. double test_exppow2_pdf (double x);
  67. double test_exppow2a (void);
  68. double test_exppow2a_pdf (double x);
  69. double test_fdist (void);
  70. double test_fdist_pdf (double x);
  71. double test_flat (void);
  72. double test_flat_pdf (double x);
  73. double test_gamma (void);
  74. double test_gamma_pdf (double x);
  75. double test_gamma1 (void);
  76. double test_gamma1_pdf (double x);
  77. double test_gamma_int (void);
  78. double test_gamma_int_pdf (double x);
  79. double test_gamma_large (void);
  80. double test_gamma_large_pdf (double x);
  81. double test_gaussian (void);
  82. double test_gaussian_pdf (double x);
  83. double test_gaussian_ratio_method (void);
  84. double test_gaussian_ratio_method_pdf (double x);
  85. double test_gaussian_tail (void);
  86. double test_gaussian_tail_pdf (double x);
  87. double test_gaussian_tail1 (void);
  88. double test_gaussian_tail1_pdf (double x);
  89. double test_gaussian_tail2 (void);
  90. double test_gaussian_tail2_pdf (double x);
  91. double test_ugaussian (void);
  92. double test_ugaussian_pdf (double x);
  93. double test_ugaussian_ratio_method (void);
  94. double test_ugaussian_ratio_method_pdf (double x);
  95. double test_ugaussian_tail (void);
  96. double test_ugaussian_tail_pdf (double x);
  97. double test_bivariate_gaussian1 (void);
  98. double test_bivariate_gaussian1_pdf (double x);
  99. double test_bivariate_gaussian2 (void);
  100. double test_bivariate_gaussian2_pdf (double x);
  101. double test_bivariate_gaussian3 (void);
  102. double test_bivariate_gaussian3_pdf (double x);
  103. double test_bivariate_gaussian4 (void);
  104. double test_bivariate_gaussian4_pdf (double x);
  105. double test_gumbel1 (void);
  106. double test_gumbel1_pdf (double x);
  107. double test_gumbel2 (void);
  108. double test_gumbel2_pdf (double x);
  109. double test_geometric (void);
  110. double test_geometric_pdf (unsigned int x);
  111. double test_geometric1 (void);
  112. double test_geometric1_pdf (unsigned int x);
  113. double test_hypergeometric1 (void);
  114. double test_hypergeometric1_pdf (unsigned int x);
  115. double test_hypergeometric2 (void);
  116. double test_hypergeometric2_pdf (unsigned int x);
  117. double test_hypergeometric3 (void);
  118. double test_hypergeometric3_pdf (unsigned int x);
  119. double test_hypergeometric4 (void);
  120. double test_hypergeometric4_pdf (unsigned int x);
  121. double test_hypergeometric5 (void);
  122. double test_hypergeometric5_pdf (unsigned int x);
  123. double test_hypergeometric6 (void);
  124. double test_hypergeometric6_pdf (unsigned int x);
  125. double test_landau (void);
  126. double test_landau_pdf (double x);
  127. double test_levy1 (void);
  128. double test_levy1_pdf (double x);
  129. double test_levy2 (void);
  130. double test_levy2_pdf (double x);
  131. double test_levy1a (void);
  132. double test_levy1a_pdf (double x);
  133. double test_levy2a (void);
  134. double test_levy2a_pdf (double x);
  135. double test_levy_skew1 (void);
  136. double test_levy_skew1_pdf (double x);
  137. double test_levy_skew2 (void);
  138. double test_levy_skew2_pdf (double x);
  139. double test_levy_skew1a (void);
  140. double test_levy_skew1a_pdf (double x);
  141. double test_levy_skew2a (void);
  142. double test_levy_skew2a_pdf (double x);
  143. double test_levy_skew1b (void);
  144. double test_levy_skew1b_pdf (double x);
  145. double test_levy_skew2b (void);
  146. double test_levy_skew2b_pdf (double x);
  147. double test_logistic (void);
  148. double test_logistic_pdf (double x);
  149. double test_lognormal (void);
  150. double test_lognormal_pdf (double x);
  151. double test_logarithmic (void);
  152. double test_logarithmic_pdf (unsigned int n);
  153. double test_negative_binomial (void);
  154. double test_negative_binomial_pdf (unsigned int n);
  155. double test_pascal (void);
  156. double test_pascal_pdf (unsigned int n);
  157. double test_pareto (void);
  158. double test_pareto_pdf (double x);
  159. double test_poisson (void);
  160. double test_poisson_pdf (unsigned int x);
  161. double test_poisson_large (void);
  162. double test_poisson_large_pdf (unsigned int x);
  163. double test_dir2d (void);
  164. double test_dir2d_pdf (double x);
  165. double test_dir2d_trig_method (void);
  166. double test_dir2d_trig_method_pdf (double x);
  167. double test_dir3dxy (void);
  168. double test_dir3dxy_pdf (double x);
  169. double test_dir3dyz (void);
  170. double test_dir3dyz_pdf (double x);
  171. double test_dir3dzx (void);
  172. double test_dir3dzx_pdf (double x);
  173. double test_rayleigh (void);
  174. double test_rayleigh_pdf (double x);
  175. double test_rayleigh_tail (void);
  176. double test_rayleigh_tail_pdf (double x);
  177. double test_tdist1 (void);
  178. double test_tdist1_pdf (double x);
  179. double test_tdist2 (void);
  180. double test_tdist2_pdf (double x);
  181. double test_laplace (void);
  182. double test_laplace_pdf (double x);
  183. double test_weibull (void);
  184. double test_weibull_pdf (double x);
  185. double test_weibull1 (void);
  186. double test_weibull1_pdf (double x);
  187.  
  188. gsl_rng *r_global;
  189.  
  190. int
  191. main (void)
  192. {
  193.   gsl_ieee_env_setup ();
  194.  
  195.   gsl_rng_env_setup() ;
  196.   r_global = gsl_rng_alloc (gsl_rng_default);
  197.  
  198. #define FUNC(x)  test_ ## x,                     "test gsl_ran_" #x
  199. #define FUNC2(x) test_ ## x, test_ ## x ## _pdf, "test gsl_ran_" #x
  200.  
  201.   test_shuffle() ;
  202.   test_choose() ;
  203.  
  204.   testMoments (FUNC (ugaussian), 0.0, 100.0, 0.5);
  205.   testMoments (FUNC (ugaussian), -1.0, 1.0, 0.6826895);
  206.   testMoments (FUNC (ugaussian), 3.0, 3.5, 0.0011172689);
  207.   testMoments (FUNC (ugaussian_tail), 3.0, 3.5, 0.0011172689/0.0013498981);
  208.   testMoments (FUNC (exponential), 0.0, 1.0, 1- exp(-0.5));
  209.   testMoments (FUNC (cauchy), 0.0, 10000.0, 0.5);
  210.  
  211.   testMoments (FUNC (discrete1), -0.5, 0.5, 0.59 );
  212.   testMoments (FUNC (discrete1), 0.5, 1.5, 0.40 );
  213.   testMoments (FUNC (discrete1), 1.5, 3.5, 0.01 );
  214.  
  215.   testPDF (FUNC2(beta));
  216.   testPDF (FUNC2(cauchy));
  217.   testPDF (FUNC2(chisq));
  218.   testPDF (FUNC2(erlang));
  219.   testPDF (FUNC2(exponential));
  220.  
  221.   testPDF (FUNC2(exppow0));
  222.   testPDF (FUNC2(exppow1));
  223.   testPDF (FUNC2(exppow1a));
  224.   testPDF (FUNC2(exppow2));
  225.   testPDF (FUNC2(exppow2a));
  226.  
  227.   testPDF (FUNC2(fdist));
  228.   testPDF (FUNC2(flat));
  229.   testPDF (FUNC2(gamma));
  230.   testPDF (FUNC2(gamma1));
  231.   testPDF (FUNC2(gamma_int));
  232.   testPDF (FUNC2(gamma_large));
  233.   testPDF (FUNC2(gaussian));
  234.   testPDF (FUNC2(gaussian_ratio_method));
  235.   testPDF (FUNC2(ugaussian));
  236.   testPDF (FUNC2(ugaussian_ratio_method));
  237.   testPDF (FUNC2(gaussian_tail));
  238.   testPDF (FUNC2(gaussian_tail1));
  239.   testPDF (FUNC2(gaussian_tail2));
  240.   testPDF (FUNC2(ugaussian_tail));
  241.   
  242.   testPDF (FUNC2(bivariate_gaussian1));
  243.   testPDF (FUNC2(bivariate_gaussian2));
  244.   testPDF (FUNC2(bivariate_gaussian3));
  245.   testPDF (FUNC2(bivariate_gaussian4));
  246.  
  247.   testPDF (FUNC2(gumbel1));
  248.   testPDF (FUNC2(gumbel2));
  249.   testPDF (FUNC2(landau));
  250.   testPDF (FUNC2(levy1));
  251.   testPDF (FUNC2(levy2));
  252.   testPDF (FUNC2(levy1a));
  253.   testPDF (FUNC2(levy2a));
  254.   testPDF (FUNC2(levy_skew1));
  255.   testPDF (FUNC2(levy_skew2));
  256.   testPDF (FUNC2(levy_skew1a));
  257.   testPDF (FUNC2(levy_skew2a));
  258.   testPDF (FUNC2(levy_skew1b));
  259.   testPDF (FUNC2(levy_skew2b));
  260.   testPDF (FUNC2(logistic));
  261.   testPDF (FUNC2(lognormal));
  262.   testPDF (FUNC2(pareto));
  263.   testPDF (FUNC2(rayleigh));
  264.   testPDF (FUNC2(rayleigh_tail));
  265.   testPDF (FUNC2(tdist1));
  266.   testPDF (FUNC2(tdist2));
  267.   testPDF (FUNC2(laplace));
  268.   testPDF (FUNC2(weibull));
  269.   testPDF (FUNC2(weibull1));
  270.  
  271.   testPDF (FUNC2(dir2d));
  272.   testPDF (FUNC2(dir2d_trig_method));
  273.   testPDF (FUNC2(dir3dxy));
  274.   testPDF (FUNC2(dir3dyz));
  275.   testPDF (FUNC2(dir3dzx));
  276.  
  277.   testDiscretePDF (FUNC2(discrete1));
  278.   testDiscretePDF (FUNC2(discrete2));
  279.   testDiscretePDF (FUNC2(poisson));
  280.   testDiscretePDF (FUNC2(poisson_large));
  281.   testDiscretePDF (FUNC2(bernoulli));
  282.   testDiscretePDF (FUNC2(binomial));
  283.   testDiscretePDF (FUNC2(binomial_large));
  284.   testDiscretePDF (FUNC2(geometric));
  285.   testDiscretePDF (FUNC2(geometric1));
  286.   testDiscretePDF (FUNC2(hypergeometric1));
  287.   testDiscretePDF (FUNC2(hypergeometric2));
  288.   testDiscretePDF (FUNC2(hypergeometric3));
  289.   testDiscretePDF (FUNC2(hypergeometric4));
  290.   testDiscretePDF (FUNC2(hypergeometric5));
  291.   testDiscretePDF (FUNC2(hypergeometric6));
  292.   testDiscretePDF (FUNC2(logarithmic));
  293.   testDiscretePDF (FUNC2(negative_binomial));
  294.   testDiscretePDF (FUNC2(pascal));
  295.  
  296.   exit (gsl_test_summary());
  297. }
  298.  
  299. void
  300. test_shuffle (void)
  301. {
  302.   double count[10][10] ;
  303.   int x[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} ;
  304.   int i, j, status = 0;
  305.  
  306.   for (i = 0; i < 10; i++)
  307.     {
  308.       for (j = 0; j < 10; j++)
  309.     {
  310.       count[i][j] = 0 ;
  311.     }
  312.     }
  313.  
  314.   for (i = 0 ; i < N; i++)
  315.     {
  316.       for (j = 0; j < 10; j++)
  317.     x[j] = j ;
  318.  
  319.       gsl_ran_shuffle (r_global, x, 10, sizeof(int)) ;
  320.  
  321.       for (j = 0; j < 10; j++)
  322.     count[x[j]][j] ++ ;
  323.     }
  324.  
  325.   for (i = 0; i < 10; i++)
  326.     {
  327.       for (j = 0; j < 10; j++)
  328.     {
  329.       double expected = N / 10.0 ;
  330.       double d = fabs(count[i][j] - expected);
  331.       double sigma = d / sqrt(expected) ;
  332.       if (sigma > 5 && d > 1)
  333.         {
  334.           status = 1 ;
  335.           gsl_test (status, 
  336.             "gsl_ran_shuffle %d,%d (%g observed vs %g expected)", 
  337.             i, j, count[i][j]/N, 0.1) ;
  338.         }
  339.     }
  340.     }
  341.   
  342.   gsl_test (status, "gsl_ran_shuffle on {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}") ;
  343.  
  344. }
  345.  
  346. void
  347. test_choose (void)
  348. {
  349.   double count[10] ;
  350.   int x[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} ;
  351.   int y[3] = {0, 1, 2} ;
  352.   int i, j, status = 0;
  353.  
  354.   for (i = 0; i < 10; i++)
  355.     {
  356.       count[i] = 0 ;
  357.     }
  358.  
  359.   for (i = 0 ; i < N; i++)
  360.     {
  361.       for (j = 0; j < 10; j++)
  362.     x[j] = j ;
  363.  
  364.       gsl_ran_choose (r_global, y, 3, x, 10, sizeof(int)) ;
  365.  
  366.       for (j = 0; j < 3; j++)
  367.     count[y[j]]++ ;
  368.     }
  369.  
  370.   for (i = 0; i < 10; i++)
  371.     {
  372.       double expected = 3.0 * N / 10.0 ;
  373.       double d = fabs(count[i] - expected);
  374.       double sigma = d / sqrt(expected) ;
  375.       if (sigma > 5 && d > 1)
  376.     {
  377.       status = 1 ;
  378.       gsl_test (status, 
  379.             "gsl_ran_choose %d (%g observed vs %g expected)", 
  380.             i, count[i]/N, 0.1) ;
  381.     }
  382.     }
  383.   
  384.   gsl_test (status, "gsl_ran_choose (3) on {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}") ;
  385.  
  386. }
  387.  
  388.  
  389.  
  390.  
  391. void
  392. testMoments (double (*f) (void), const char *name,
  393.           double a, double b, double p)
  394. {
  395.   int i;
  396.   double count = 0, expected, sigma;
  397.   int status;
  398.  
  399.   for (i = 0; i < N; i++)
  400.     {
  401.       double r = f ();
  402.       if (r < b && r > a)
  403.     count++;
  404.     }
  405.  
  406.   expected = p * N;
  407.   sigma = fabs (count - expected) / sqrt (expected);
  408.  
  409.   status = (sigma > 3);
  410.  
  411.   gsl_test (status, "%s [%g,%g] (%g observed vs %g expected)",
  412.         name, a, b, count / N, p);
  413. }
  414.  
  415. #define BINS 100
  416.  
  417. void
  418. testPDF (double (*f) (void), double (*pdf)(double), const char *name)
  419. {
  420.   double count[BINS], p[BINS];
  421.   double a = -5.0, b = +5.0 ;
  422.   double dx = (b - a) / BINS ;
  423.   int i,j,status = 0, status_i =0 ;
  424.  
  425.   for (i = 0; i < BINS; i++)
  426.     count[i] = 0 ;
  427.  
  428.   for (i = 0; i < N; i++)
  429.     {
  430.       double r = f ();
  431.       if (r < b && r > a)
  432.     { 
  433.       j =  (int)((r - a)/dx) ;
  434.       count[j]++;
  435.     }
  436.     }
  437.   
  438.   for (i = 0; i < BINS; i++)
  439.     {
  440.       /* Compute an approximation to the integral of p(x) from x to
  441.          x+dx using Simpson's rule */
  442.  
  443.       double x = a + i * dx ;
  444. #define STEPS 100
  445.       double sum = 0 ;
  446.       
  447.       if (fabs(x) < 1e-10) /* hit the origin exactly */
  448.     x = 0.0 ; 
  449.       
  450.       for (j = 1; j < STEPS; j++)
  451.     sum += pdf(x + j * dx / STEPS) ;
  452.  
  453.       p[i] =  0.5 * (pdf(x) + 2*sum + pdf(x + dx - 1e-7)) * dx / STEPS ;
  454.     }
  455.  
  456.   for (i = 0; i < BINS; i++)
  457.     {
  458.       double x = a + i * dx ;
  459.       double d = fabs(count[i] - N*p[i]) ;
  460.       if (p[i] != 0)
  461.     {
  462.       double s = d / sqrt(N*p[i]) ;
  463.       status_i = (s > 5) && (d > 1) ;
  464.     }
  465.       else
  466.     {
  467.       status_i = (count[i] != 0) ;
  468.     }
  469.       status |= status_i ;
  470.       if (status_i) 
  471.     gsl_test (status_i, "%s [%g,%g) (%g/%d=%g observed vs %g expected)", 
  472.           name, x, x+dx, count[i],N,count[i]/N, p[i]) ;
  473.     }
  474.  
  475.   if (status == 0)
  476.     gsl_test (status, "%s, sampling against pdf over range [%g,%g) ", 
  477.           name, a, b) ;
  478. }
  479.  
  480. void
  481. testDiscretePDF (double (*f) (void), double (*pdf)(unsigned int), const char *name)
  482. {
  483.   double count[BINS], p[BINS];
  484.   unsigned int i ;
  485.   int status = 0, status_i =0 ;
  486.  
  487.   for (i = 0; i < BINS; i++)
  488.     count[i] = 0 ;
  489.  
  490.   for (i = 0; i < N; i++)
  491.     {
  492.       int r = (int)(f ());
  493.       if (r>= 0 && r < BINS)
  494.     count[r]++;
  495.     }
  496.   
  497.   for (i = 0; i < BINS; i++)
  498.     p[i] =  pdf(i) ;
  499.  
  500.   for (i = 0; i < BINS; i++)
  501.     {
  502.       double d = fabs(count[i] - N*p[i]) ;
  503.       if (p[i] != 0)
  504.     {
  505.       double s = d/sqrt(N*p[i]) ;
  506.       status_i = (s > 5) && (d > 1);
  507.     }
  508.       else
  509.     {
  510.       status_i = (count[i] != 0) ;
  511.     }
  512.       status |= status_i ;
  513.       if (status_i) 
  514.     gsl_test (status_i, "%s i=%d (%g observed vs %g expected)", 
  515.           name, i, count[i]/N, p[i]) ;
  516.     }
  517.  
  518.   if (status == 0)
  519.     gsl_test (status, "%s, sampling against pdf over range [%d,%d) ", 
  520.           name, 0, BINS) ;
  521. }
  522.  
  523.       
  524.  
  525. double
  526. test_beta (void)
  527. {
  528.   return gsl_ran_beta (r_global, 2.0, 3.0);
  529. }
  530.  
  531. double
  532. test_beta_pdf (double x)
  533. {
  534.   return gsl_ran_beta_pdf (x, 2.0, 3.0);
  535. }
  536.  
  537. double
  538. test_bernoulli (void)
  539. {
  540.   return gsl_ran_bernoulli (r_global, 0.3);
  541. }
  542.  
  543. double
  544. test_bernoulli_pdf (unsigned int n)
  545. {
  546.   return gsl_ran_bernoulli_pdf (n, 0.3);
  547. }
  548.  
  549.  
  550. double
  551. test_binomial (void)
  552. {
  553.   return gsl_ran_binomial (r_global, 0.3, 5);
  554. }
  555.  
  556. double
  557. test_binomial_pdf (unsigned int n)
  558. {
  559.   return gsl_ran_binomial_pdf (n, 0.3, 5);
  560. }
  561.  
  562. double
  563. test_binomial_large (void)
  564. {
  565.   return gsl_ran_binomial (r_global, 0.3, 55);
  566. }
  567.  
  568. double
  569. test_binomial_large_pdf (unsigned int n)
  570. {
  571.   return gsl_ran_binomial_pdf (n, 0.3, 55);
  572. }
  573.  
  574. double
  575. test_cauchy (void)
  576. {
  577.   return gsl_ran_cauchy (r_global, 2.0);
  578. }
  579.  
  580. double
  581. test_cauchy_pdf (double x)
  582. {
  583.   return gsl_ran_cauchy_pdf (x, 2.0);
  584. }
  585.  
  586. double
  587. test_chisq (void)
  588. {
  589.   return gsl_ran_chisq (r_global, 13.0);
  590. }
  591.  
  592. double
  593. test_chisq_pdf (double x)
  594. {
  595.   return gsl_ran_chisq_pdf (x, 13.0);
  596. }
  597.  
  598. double
  599. test_dir2d (void)
  600. {
  601.   double x=0, y=0, theta;
  602.   gsl_ran_dir_2d (r_global, &x, &y);
  603.   theta = atan2(x,y);
  604.   return theta;
  605. }
  606.  
  607. double
  608. test_dir2d_pdf (double x)
  609. {
  610.   if (x > -M_PI && x <= M_PI)
  611.     {
  612.       return 1 / (2 * M_PI) ;
  613.     }
  614.   else
  615.     {
  616.       return 0 ;
  617.     }
  618. }
  619.  
  620. double
  621. test_dir2d_trig_method (void)
  622. {
  623.   double x=0, y=0, theta;
  624.   gsl_ran_dir_2d_trig_method (r_global, &x, &y);
  625.   theta = atan2(x,y);
  626.   return theta;
  627. }
  628.  
  629. double
  630. test_dir2d_trig_method_pdf (double x)
  631. {
  632.   if (x > -M_PI && x <= M_PI)
  633.     {
  634.       return 1 / (2 * M_PI) ;
  635.     }
  636.   else
  637.     {
  638.       return 0 ;
  639.     }
  640. }
  641.  
  642. double
  643. test_dir3dxy (void)
  644. {
  645.   double x=0, y=0, z=0, theta;
  646.   gsl_ran_dir_3d (r_global, &x, &y, &z);
  647.   theta = atan2(x,y);
  648.   return theta;
  649. }
  650.  
  651. double
  652. test_dir3dxy_pdf (double x)
  653. {
  654.   if (x > -M_PI && x <= M_PI)
  655.     {
  656.       return 1 / (2 * M_PI) ;
  657.     }
  658.   else
  659.     {
  660.       return 0 ;
  661.     }
  662. }
  663.  
  664. double
  665. test_dir3dyz (void)
  666. {
  667.   double x=0, y=0, z=0, theta;
  668.   gsl_ran_dir_3d (r_global, &x, &y, &z);
  669.   theta = atan2(y,z);
  670.   return theta;
  671. }
  672.  
  673. double
  674. test_dir3dyz_pdf (double x)
  675. {
  676.   if (x > -M_PI && x <= M_PI)
  677.     {
  678.       return 1 / (2 * M_PI) ;
  679.     }
  680.   else
  681.     {
  682.       return 0 ;
  683.     }
  684. }
  685.  
  686. double
  687. test_dir3dzx (void)
  688. {
  689.   double x=0, y=0, z=0, theta;
  690.   gsl_ran_dir_3d (r_global, &x, &y, &z);
  691.   theta = atan2(z,x);
  692.   return theta;
  693. }
  694.  
  695. double
  696. test_dir3dzx_pdf (double x)
  697. {
  698.   if (x > -M_PI && x <= M_PI)
  699.     {
  700.       return 1 / (2 * M_PI) ;
  701.     }
  702.   else
  703.     {
  704.       return 0 ;
  705.     }
  706. }
  707.  
  708. static gsl_ran_discrete_t *g1 = NULL;
  709. static gsl_ran_discrete_t *g2 = NULL;
  710.  
  711. double
  712. test_discrete1 (void)
  713. {
  714.     static double P[3]={0.59, 0.4, 0.01};
  715.     if (g1==NULL) {
  716.         g1 = gsl_ran_discrete_preproc(3,P);
  717.     }
  718.     return gsl_ran_discrete(r_global,g1);
  719. }
  720. double test_discrete1_pdf (unsigned int n)
  721. {
  722.     return gsl_ran_discrete_pdf((size_t)n,g1);
  723. }
  724.  
  725. double
  726. test_discrete2 (void)
  727. {
  728.     static double P[10]={ 1, 9, 3, 4, 5, 8, 6, 7, 2, 0 };
  729.     if (g2==NULL) {
  730.         g2 = gsl_ran_discrete_preproc(10,P);
  731.     }
  732.     return gsl_ran_discrete(r_global,g2);
  733. }
  734. double test_discrete2_pdf (unsigned int n)
  735. {
  736.     return gsl_ran_discrete_pdf((size_t)n,g2);
  737. }
  738.  
  739.     
  740. double
  741. test_erlang (void)
  742. {
  743.   return gsl_ran_erlang (r_global, 3.0, 4.0);
  744. }
  745.  
  746. double
  747. test_erlang_pdf (double x)
  748. {
  749.   return gsl_ran_erlang_pdf (x, 3.0, 4.0);
  750. }
  751.  
  752. double
  753. test_exponential (void)
  754. {
  755.   return gsl_ran_exponential (r_global, 2.0);
  756. }
  757.  
  758. double
  759. test_exponential_pdf (double x)
  760. {
  761.   return gsl_ran_exponential_pdf (x, 2.0);
  762. }
  763.  
  764. double
  765. test_exppow0 (void)
  766. {
  767.   return gsl_ran_exppow (r_global, 3.7, 0.3);
  768. }
  769.  
  770. double
  771. test_exppow0_pdf (double x)
  772. {
  773.   return gsl_ran_exppow_pdf (x, 3.7, 0.3);
  774. }
  775.  
  776. double
  777. test_exppow1 (void)
  778. {
  779.   return gsl_ran_exppow (r_global, 3.7, 1.0);
  780. }
  781.  
  782. double
  783. test_exppow1_pdf (double x)
  784. {
  785.   return gsl_ran_exppow_pdf (x, 3.7, 1.0);
  786. }
  787.  
  788. double
  789. test_exppow1a (void)
  790. {
  791.   return gsl_ran_exppow (r_global, 3.7, 1.9);
  792. }
  793.  
  794. double
  795. test_exppow1a_pdf (double x)
  796. {
  797.   return gsl_ran_exppow_pdf (x, 3.7, 1.9);
  798. }
  799.  
  800. double
  801. test_exppow2 (void)
  802. {
  803.   return gsl_ran_exppow (r_global, 3.7, 2.0);
  804. }
  805.  
  806. double
  807. test_exppow2_pdf (double x)
  808. {
  809.   return gsl_ran_exppow_pdf (x, 3.7, 2.0);
  810. }
  811.  
  812.  
  813. double
  814. test_exppow2a (void)
  815. {
  816.   return gsl_ran_exppow (r_global, 3.7, 7.5);
  817. }
  818.  
  819. double
  820. test_exppow2a_pdf (double x)
  821. {
  822.   return gsl_ran_exppow_pdf (x, 3.7, 7.5);
  823. }
  824.  
  825. double
  826. test_fdist (void)
  827. {
  828.   return gsl_ran_fdist (r_global, 3.0, 4.0);
  829. }
  830.  
  831. double
  832. test_fdist_pdf (double x)
  833. {
  834.   return gsl_ran_fdist_pdf (x, 3.0, 4.0);
  835. }
  836.  
  837. double
  838. test_flat (void)
  839. {
  840.   return gsl_ran_flat (r_global, 3.0, 4.0);
  841. }
  842.  
  843. double
  844. test_flat_pdf (double x)
  845. {
  846.   return gsl_ran_flat_pdf (x, 3.0, 4.0);
  847. }
  848.  
  849. double
  850. test_gamma (void)
  851. {
  852.   return gsl_ran_gamma (r_global, 2.5, 2.17);
  853. }
  854.  
  855. double
  856. test_gamma_pdf (double x)
  857. {
  858.   return gsl_ran_gamma_pdf (x, 2.5, 2.17);
  859. }
  860.  
  861. double
  862. test_gamma1 (void)
  863. {
  864.   return gsl_ran_gamma (r_global, 1.0, 2.17);
  865. }
  866.  
  867. double
  868. test_gamma1_pdf (double x)
  869. {
  870.   return gsl_ran_gamma_pdf (x, 1.0, 2.17);
  871. }
  872.  
  873.  
  874. double
  875. test_gamma_int (void)
  876. {
  877.   return gsl_ran_gamma (r_global, 10.0, 2.17);
  878. }
  879.  
  880. double
  881. test_gamma_int_pdf (double x)
  882. {
  883.   return gsl_ran_gamma_pdf (x, 10.0, 2.17);
  884. }
  885.  
  886.  
  887. double
  888. test_gamma_large (void)
  889. {
  890.   return gsl_ran_gamma (r_global, 20.0, 2.17);
  891. }
  892.  
  893. double
  894. test_gamma_large_pdf (double x)
  895. {
  896.   return gsl_ran_gamma_pdf (x, 20.0, 2.17);
  897. }
  898.  
  899.  
  900. double
  901. test_gaussian (void)
  902. {
  903.   return gsl_ran_gaussian (r_global, 3.0);
  904. }
  905.  
  906. double
  907. test_gaussian_pdf (double x)
  908. {
  909.   return gsl_ran_gaussian_pdf (x, 3.0);
  910. }
  911.  
  912. double
  913. test_gaussian_ratio_method (void)
  914. {
  915.   return gsl_ran_gaussian_ratio_method (r_global, 3.0);
  916. }
  917.  
  918. double
  919. test_gaussian_ratio_method_pdf (double x)
  920. {
  921.   return gsl_ran_gaussian_pdf (x, 3.0);
  922. }
  923.  
  924. double
  925. test_gaussian_tail (void)
  926. {
  927.   return gsl_ran_gaussian_tail (r_global, 1.7, 0.25);
  928. }
  929.  
  930. double
  931. test_gaussian_tail_pdf (double x)
  932. {
  933.   return gsl_ran_gaussian_tail_pdf (x, 1.7, 0.25) ;
  934. }
  935.  
  936. double
  937. test_gaussian_tail1 (void)
  938. {
  939.   return gsl_ran_gaussian_tail (r_global, -1.7, 5.0);
  940. }
  941.  
  942. double
  943. test_gaussian_tail1_pdf (double x)
  944. {
  945.   return gsl_ran_gaussian_tail_pdf (x, -1.7, 5.0) ;
  946. }
  947.  
  948. double
  949. test_gaussian_tail2 (void)
  950. {
  951.   return gsl_ran_gaussian_tail (r_global, 0.1, 2.0);
  952. }
  953.  
  954. double
  955. test_gaussian_tail2_pdf (double x)
  956. {
  957.   return gsl_ran_gaussian_tail_pdf (x, 0.1, 2.0) ;
  958. }
  959.  
  960.  
  961. double
  962. test_ugaussian (void)
  963. {
  964.   return gsl_ran_ugaussian (r_global);
  965. }
  966.  
  967. double
  968. test_ugaussian_pdf (double x)
  969. {
  970.   return gsl_ran_ugaussian_pdf (x);
  971. }
  972.  
  973. double
  974. test_ugaussian_ratio_method (void)
  975. {
  976.   return gsl_ran_ugaussian_ratio_method (r_global);
  977. }
  978.  
  979. double
  980. test_ugaussian_ratio_method_pdf (double x)
  981. {
  982.   return gsl_ran_ugaussian_pdf (x);
  983. }
  984.  
  985. double
  986. test_ugaussian_tail (void)
  987. {
  988.   return gsl_ran_ugaussian_tail (r_global, 3.0);
  989. }
  990.  
  991. double
  992. test_ugaussian_tail_pdf (double x)
  993. {
  994.   return gsl_ran_ugaussian_tail_pdf (x, 3.0) ;
  995. }
  996.  
  997. double
  998. test_bivariate_gaussian1 (void)
  999. {
  1000.   double x = 0, y = 0;
  1001.   gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);
  1002.   return x ;
  1003. }
  1004.  
  1005. double
  1006. test_bivariate_gaussian1_pdf (double x)
  1007. {
  1008.   return gsl_ran_gaussian_pdf (x, 3.0);
  1009. }
  1010.  
  1011. double
  1012. test_bivariate_gaussian2 (void)
  1013. {
  1014.   double x = 0, y = 0;
  1015.   gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);
  1016.   return y ;
  1017. }
  1018.  
  1019. double
  1020. test_bivariate_gaussian2_pdf (double y)
  1021. {
  1022.   int i, n = 10 ;
  1023.   double sum = 0 ;
  1024.   double a = -10, b = 10, dx = (b - a)/n ;
  1025.   for (i = 0; i < n ; i++)
  1026.     {
  1027.       double x = a + i * dx ;
  1028.       sum += gsl_ran_bivariate_gaussian_pdf (x, y, 3.0, 2.0, 0.3) * dx ;
  1029.     }
  1030.   return sum ;
  1031. }
  1032.  
  1033.  
  1034. double
  1035. test_bivariate_gaussian3 (void)
  1036. {
  1037.   double x = 0, y = 0;
  1038.   gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);
  1039.   return x + y ;
  1040. }
  1041.  
  1042. double
  1043. test_bivariate_gaussian3_pdf (double x)
  1044. {
  1045.   double sx = 3.0, sy = 2.0, r = 0.3;
  1046.   double su = (sx+r*sy) ;
  1047.   double sv = sy*sqrt(1-r*r) ;
  1048.   double sigma = sqrt(su*su + sv*sv) ;
  1049.     
  1050.   return gsl_ran_gaussian_pdf (x, sigma);
  1051. }
  1052.  
  1053. double
  1054. test_bivariate_gaussian4 (void)
  1055. {
  1056.   double x = 0, y = 0;
  1057.   gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, -0.5, &x, &y);
  1058.   return x + y ;
  1059. }
  1060.  
  1061. double
  1062. test_bivariate_gaussian4_pdf (double x)
  1063. {
  1064.   double sx = 3.0, sy = 2.0, r = -0.5;
  1065.   double su = (sx+r*sy) ;
  1066.   double sv = sy*sqrt(1-r*r) ;
  1067.   double sigma = sqrt(su*su + sv*sv) ;
  1068.     
  1069.   return gsl_ran_gaussian_pdf (x, sigma);
  1070. }
  1071.  
  1072.  
  1073. double
  1074. test_geometric (void)
  1075. {
  1076.   return gsl_ran_geometric (r_global, 0.5);
  1077. }
  1078.  
  1079. double
  1080. test_geometric_pdf (unsigned int n)
  1081. {
  1082.   return gsl_ran_geometric_pdf (n, 0.5);
  1083. }
  1084.  
  1085. double
  1086. test_geometric1 (void)
  1087. {
  1088.   return gsl_ran_geometric (r_global, 1.0);
  1089. }
  1090.  
  1091. double
  1092. test_geometric1_pdf (unsigned int n)
  1093. {
  1094.   return gsl_ran_geometric_pdf (n, 1.0);
  1095. }
  1096.  
  1097. double
  1098. test_hypergeometric1 (void)
  1099. {
  1100.   return gsl_ran_hypergeometric (r_global, 5, 7, 4);
  1101. }
  1102.  
  1103. double
  1104. test_hypergeometric1_pdf (unsigned int n)
  1105. {
  1106.   return gsl_ran_hypergeometric_pdf (n, 5, 7, 4);
  1107. }
  1108.  
  1109.  
  1110. double
  1111. test_hypergeometric2 (void)
  1112. {
  1113.   return gsl_ran_hypergeometric (r_global, 5, 7, 11);
  1114. }
  1115.  
  1116. double
  1117. test_hypergeometric2_pdf (unsigned int n)
  1118. {
  1119.   return gsl_ran_hypergeometric_pdf (n, 5, 7, 11);
  1120. }
  1121.  
  1122. double
  1123. test_hypergeometric3 (void)
  1124. {
  1125.   return gsl_ran_hypergeometric (r_global, 5, 7, 1);
  1126. }
  1127.  
  1128. double
  1129. test_hypergeometric3_pdf (unsigned int n)
  1130. {
  1131.   return gsl_ran_hypergeometric_pdf (n, 5, 7, 1);
  1132. }
  1133.  
  1134. double
  1135. test_hypergeometric4 (void)
  1136. {
  1137.   return gsl_ran_hypergeometric (r_global, 5, 7, 20);
  1138. }
  1139.  
  1140. double
  1141. test_hypergeometric4_pdf (unsigned int n)
  1142. {
  1143.   return gsl_ran_hypergeometric_pdf (n, 5, 7, 20);
  1144. }
  1145.  
  1146. double
  1147. test_hypergeometric5 (void)
  1148. {
  1149.   return gsl_ran_hypergeometric (r_global, 2, 7, 5);
  1150. }
  1151.  
  1152. double
  1153. test_hypergeometric5_pdf (unsigned int n)
  1154. {
  1155.   return gsl_ran_hypergeometric_pdf (n, 2, 7, 5);
  1156. }
  1157.  
  1158.  
  1159. double
  1160. test_hypergeometric6 (void)
  1161. {
  1162.   return gsl_ran_hypergeometric (r_global, 2, 10, 3);
  1163. }
  1164.  
  1165. double
  1166. test_hypergeometric6_pdf (unsigned int n)
  1167. {
  1168.   return gsl_ran_hypergeometric_pdf (n, 2, 10, 3);
  1169. }
  1170.  
  1171.  
  1172.  
  1173.  
  1174. double
  1175. test_gumbel1 (void)
  1176. {
  1177.   return gsl_ran_gumbel1 (r_global, 3.12, 4.56);
  1178. }
  1179.  
  1180. double
  1181. test_gumbel1_pdf (double x)
  1182. {
  1183.   return gsl_ran_gumbel1_pdf (x, 3.12, 4.56);
  1184. }
  1185.  
  1186. double
  1187. test_gumbel2 (void)
  1188. {
  1189.   return gsl_ran_gumbel2 (r_global, 3.12, 4.56);
  1190. }
  1191.  
  1192. double
  1193. test_gumbel2_pdf (double x)
  1194. {
  1195.   return gsl_ran_gumbel2_pdf (x, 3.12, 4.56);
  1196. }
  1197.  
  1198. double
  1199. test_landau (void)
  1200. {
  1201.   return gsl_ran_landau (r_global);
  1202. }
  1203.  
  1204. double
  1205. test_landau_pdf (double x)
  1206. {
  1207.   return gsl_ran_landau_pdf (x);
  1208. }
  1209.  
  1210. double
  1211. test_levy1 (void)
  1212. {
  1213.   return gsl_ran_levy (r_global, 5.0, 1.0);
  1214. }
  1215.  
  1216. double
  1217. test_levy1_pdf (double x)
  1218. {
  1219.   return gsl_ran_cauchy_pdf (x, 5.0);
  1220. }
  1221.  
  1222. double
  1223. test_levy2 (void)
  1224. {
  1225.   return gsl_ran_levy (r_global, 5.0, 2.0);
  1226. }
  1227.  
  1228. double
  1229. test_levy2_pdf (double x)
  1230. {
  1231.   return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );
  1232. }
  1233.  
  1234. double
  1235. test_levy1a (void)
  1236. {
  1237.   return gsl_ran_levy (r_global, 5.0, 1.01);
  1238. }
  1239.  
  1240. double
  1241. test_levy1a_pdf (double x)
  1242. {
  1243.   return gsl_ran_cauchy_pdf (x, 5.0);
  1244. }
  1245.  
  1246. double
  1247. test_levy2a (void)
  1248. {
  1249.   return gsl_ran_levy (r_global, 5.0, 1.99);
  1250. }
  1251.  
  1252. double
  1253. test_levy2a_pdf (double x)
  1254. {
  1255.   return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );
  1256. }
  1257.  
  1258.  
  1259. double
  1260. test_levy_skew1 (void)
  1261. {
  1262.   return gsl_ran_levy_skew (r_global, 5.0, 1.0, 0.0);
  1263. }
  1264.  
  1265. double
  1266. test_levy_skew1_pdf (double x)
  1267. {
  1268.   return gsl_ran_cauchy_pdf (x, 5.0);
  1269. }
  1270.  
  1271. double
  1272. test_levy_skew2 (void)
  1273. {
  1274.   return gsl_ran_levy_skew (r_global, 5.0, 2.0, 0.0);
  1275. }
  1276.  
  1277. double
  1278. test_levy_skew2_pdf (double x)
  1279. {
  1280.   return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );
  1281. }
  1282.  
  1283. double
  1284. test_levy_skew1a (void)
  1285. {
  1286.   return gsl_ran_levy_skew (r_global, 5.0, 1.01, 0.0);
  1287. }
  1288.  
  1289. double
  1290. test_levy_skew1a_pdf (double x)
  1291. {
  1292.   return gsl_ran_cauchy_pdf (x, 5.0);
  1293. }
  1294.  
  1295. double
  1296. test_levy_skew2a (void)
  1297. {
  1298.   return gsl_ran_levy_skew (r_global, 5.0, 1.99, 0.0);
  1299. }
  1300.  
  1301. double
  1302. test_levy_skew2a_pdf (double x)
  1303. {
  1304.   return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );
  1305. }
  1306.  
  1307. double
  1308. test_levy_skew1b (void)
  1309. {
  1310.   return gsl_ran_levy_skew (r_global, 5.0, 1.01, 0.001);
  1311. }
  1312.  
  1313. double
  1314. test_levy_skew1b_pdf (double x)
  1315. {
  1316.   return gsl_ran_cauchy_pdf (x, 5.0);
  1317. }
  1318.  
  1319. double
  1320. test_levy_skew2b (void)
  1321. {
  1322.   return gsl_ran_levy_skew (r_global, 5.0, 1.99, 0.001);
  1323. }
  1324.  
  1325. double
  1326. test_levy_skew2b_pdf (double x)
  1327. {
  1328.   return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );
  1329. }
  1330.  
  1331.  
  1332. double
  1333. test_logistic (void)
  1334. {
  1335.   return gsl_ran_logistic (r_global, 3.1);
  1336. }
  1337.  
  1338. double
  1339. test_logistic_pdf (double x)
  1340. {
  1341.   return gsl_ran_logistic_pdf (x, 3.1);
  1342. }
  1343.  
  1344. double
  1345. test_logarithmic (void)
  1346. {
  1347.   return gsl_ran_logarithmic (r_global, 0.4);
  1348. }
  1349.  
  1350. double
  1351. test_logarithmic_pdf (unsigned int n)
  1352. {
  1353.   return gsl_ran_logarithmic_pdf (n, 0.4);
  1354. }
  1355.  
  1356.  
  1357. double
  1358. test_lognormal (void)
  1359. {
  1360.   return gsl_ran_lognormal (r_global, 2.7, 1.3);
  1361. }
  1362.  
  1363. double
  1364. test_lognormal_pdf (double x)
  1365. {
  1366.   return gsl_ran_lognormal_pdf (x, 2.7, 1.3);
  1367. }
  1368.  
  1369. double
  1370. test_negative_binomial (void)
  1371. {
  1372.   return gsl_ran_negative_binomial (r_global, 0.3, 20.0);
  1373. }
  1374.  
  1375. double
  1376. test_negative_binomial_pdf (unsigned int n)
  1377. {
  1378.   return gsl_ran_negative_binomial_pdf (n, 0.3, 20.0);
  1379. }
  1380.  
  1381. double
  1382. test_pascal (void)
  1383. {
  1384.   return gsl_ran_pascal (r_global, 0.8, 3);
  1385. }
  1386.  
  1387. double
  1388. test_pascal_pdf (unsigned int n)
  1389. {
  1390.   return gsl_ran_pascal_pdf (n, 0.8, 3);
  1391. }
  1392.  
  1393.  
  1394. double
  1395. test_pareto (void)
  1396. {
  1397.   return gsl_ran_pareto (r_global, 1.9, 2.75);
  1398. }
  1399.  
  1400. double
  1401. test_pareto_pdf (double x)
  1402. {
  1403.   return gsl_ran_pareto_pdf (x, 1.9, 2.75);
  1404. }
  1405.  
  1406. double
  1407. test_rayleigh (void)
  1408. {
  1409.   return gsl_ran_rayleigh (r_global, 1.9);
  1410. }
  1411.  
  1412. double
  1413. test_rayleigh_pdf (double x)
  1414. {
  1415.   return gsl_ran_rayleigh_pdf (x, 1.9);
  1416. }
  1417.  
  1418. double
  1419. test_rayleigh_tail (void)
  1420. {
  1421.   return gsl_ran_rayleigh_tail (r_global, 2.7, 1.9);
  1422. }
  1423.  
  1424. double
  1425. test_rayleigh_tail_pdf (double x)
  1426. {
  1427.   return gsl_ran_rayleigh_tail_pdf (x, 2.7, 1.9);
  1428. }
  1429.  
  1430.  
  1431. double
  1432. test_poisson (void)
  1433. {
  1434.   return gsl_ran_poisson (r_global, 5.0);
  1435. }
  1436.  
  1437. double
  1438. test_poisson_pdf (unsigned int n)
  1439. {
  1440.   return gsl_ran_poisson_pdf (n, 5.0);
  1441. }
  1442.  
  1443. double
  1444. test_poisson_large (void)
  1445. {
  1446.   return gsl_ran_poisson (r_global, 30.0);
  1447. }
  1448.  
  1449. double
  1450. test_poisson_large_pdf (unsigned int n)
  1451. {
  1452.   return gsl_ran_poisson_pdf (n, 30.0);
  1453. }
  1454.  
  1455.  
  1456. double
  1457. test_tdist1 (void)
  1458. {
  1459.   return gsl_ran_tdist (r_global, 1.75);
  1460. }
  1461.  
  1462. double
  1463. test_tdist1_pdf (double x)
  1464. {
  1465.   return gsl_ran_tdist_pdf (x, 1.75);
  1466. }
  1467.  
  1468. double
  1469. test_tdist2 (void)
  1470. {
  1471.   return gsl_ran_tdist (r_global, 12.75);
  1472. }
  1473.  
  1474. double
  1475. test_tdist2_pdf (double x)
  1476. {
  1477.   return gsl_ran_tdist_pdf (x, 12.75);
  1478. }
  1479.  
  1480.  
  1481. double
  1482. test_laplace (void)
  1483. {
  1484.   return gsl_ran_laplace (r_global, 2.75);
  1485. }
  1486.  
  1487. double
  1488. test_laplace_pdf (double x)
  1489. {
  1490.   return gsl_ran_laplace_pdf (x, 2.75);
  1491. }
  1492.  
  1493. double
  1494. test_weibull (void)
  1495. {
  1496.   return gsl_ran_weibull (r_global, 3.14, 2.75);
  1497. }
  1498.  
  1499. double
  1500. test_weibull_pdf (double x)
  1501. {
  1502.   return gsl_ran_weibull_pdf (x, 3.14, 2.75);
  1503. }
  1504.  
  1505.  
  1506. double
  1507. test_weibull1 (void)
  1508. {
  1509.   return gsl_ran_weibull (r_global, 2.97, 1.0);
  1510. }
  1511.  
  1512. double
  1513. test_weibull1_pdf (double x)
  1514. {
  1515.   return gsl_ran_weibull_pdf (x, 2.97, 1.0);
  1516. }
  1517.